home *** CD-ROM | disk | FTP | other *** search
/ Aminet 2 / Aminet AMIGA CDROM (1994)(Walnut Creek)[Feb 1994][W.O. 44790-1].iso / Aminet / dev / misc / toolbox.lha / Toolbox / lib / rex / Scanner.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-13  |  16.3 KB  |  447 lines
  1. /* $Id: Scanner.c,v 2.16 1992/08/18 09:05:32 grosch rel $ */
  2.  
  3. # define bool        char
  4. # define true        1
  5. # define false        0
  6. # define StdIn        0
  7.  
  8. $@ # include "@.h"
  9. $@ # include "$Source.h"
  10. # include "System.h"
  11. # include "General.h"
  12. # include "DynArray.h"
  13. # include "Positions.h"
  14. # include <stdio.h>
  15.  
  16. # if defined __STDC__ | defined __cplusplus
  17. #  include <stdlib.h>
  18. # else
  19. /* extern char * malloc ();
  20.    extern void free (); */
  21. # endif
  22.  
  23. # define yyTabSpace    8
  24.  
  25. # define yyStart(State)    { yyPreviousStart = yyStartState; yyStartState = State; }
  26. # define yyPrevious    { yyStateRange s = yyStartState; \
  27.              yyStartState = yyPreviousStart; yyPreviousStart = s; }
  28. $@ # define yyEcho        { char * yyEnd = $_TokenPtr + $_TokenLength; \
  29.             char yyCh = * yyEnd; * yyEnd = '\0'; \
  30. $@              (void) fputs ($_TokenPtr, stdout); * yyEnd = yyCh; }
  31. $@ # define yyLess(n)    { yyChBufferIndex -= $_TokenLength - n; $_TokenLength = n; }
  32. $@ # define yyTab        yyLineStart -= yyTabSpace - 1 - ((unsigned char *) $_TokenPtr - yyLineStart - 1) % yyTabSpace
  33. $@ # define yyTab1(a)    yyLineStart -= yyTabSpace - 1 - ((unsigned char *) $_TokenPtr - yyLineStart + a - 1) % yyTabSpace
  34. $@ # define yyTab2(a,b)    yyLineStart -= yyTabSpace - 1 - ((unsigned char *) $_TokenPtr - yyLineStart + a - 1) % yyTabSpace
  35. # define yyEol(Column)    { yyLineCount ++; yyLineStart = yyChBufferIndex - 1 - Column; }
  36. # define output(c)    (void) putchar ((int) c)
  37. # define unput(c)    * (-- yyChBufferIndex) = c
  38.  
  39. # define yyDNoState        0
  40. # define yyFileStackSize    16
  41. # define yyInitBufferSize    1024 * 8 + 256
  42. $C constant declarations
  43.  
  44. static void yyExit () { Exit (1); }
  45.  
  46. typedef unsigned short    yyStateRange;
  47. typedef struct { yyStateRange yyCheck, yyNext; } yyCombType;
  48.  
  49. $@     char *        $_TokenPtr    ;
  50. $@     short        $_TokenLength    ;
  51. $@     $_tScanAttribute    $_Attribute    ;
  52. $@     void        (* @_Exit) () = yyExit;
  53.  
  54. static    yyCombType    yyComb        [yyTableSize   + 1] = {{1, 0},
  55. $T
  56. };
  57. static    yyCombType *    yyBasePtr    [yyDStateCount + 1] = {& yyComb [0],
  58. $B
  59. };
  60. static    yyStateRange    yyDefault    [yyDStateCount + 1] = {0,
  61. $U
  62. };
  63. static    yyStateRange    yyEobTrans    [yyDStateCount + 1] = {0,
  64. $R
  65. };
  66. $M static short        yyAction    [yyDStateCount + 1] = {0,
  67. $Q
  68. $M };
  69.  
  70. static    yyStateRange    yyInitStateStack [yyInitBufferSize] = {0};
  71. static    yyStateRange *    yyStateStack    = yyInitStateStack;
  72. static    unsigned long    yyStateStackSize= yyInitBufferSize;
  73. static    yyStateRange    yyStartState    = 0;
  74. static    yyStateRange    yyPreviousStart    = 1;
  75.  
  76. static  short        yySourceFile    ;
  77. static    bool        yyEof        ;
  78. static    unsigned char *    yyChBufferPtr    ;
  79. static    unsigned char *    yyChBufferStart    ;
  80. static    unsigned long    yyChBufferSize    ;
  81. static    unsigned char *    yyChBufferIndex    = ((unsigned char *) yyComb) + 2; /* dirty trick */
  82. static    int        yyBytesRead    ;
  83. static    int        yyLineCount    ;
  84. static    unsigned char *    yyLineStart    ;
  85.  
  86. static    struct {
  87.     short        yySourceFile    ;
  88.     bool        yyEof        ;
  89.     unsigned char *    yyChBufferPtr    ;
  90.     unsigned char *    yyChBufferStart    ;
  91.     unsigned long    yyChBufferSize    ;
  92.     unsigned char *    yyChBufferIndex    ;
  93.     int        yyBytesRead    ;
  94.     int        yyLineCount    ;
  95.     unsigned char *    yyLineStart    ;
  96.     } yyFileStack [yyFileStackSize + 1], * yyFileStackPtr = yyFileStack;
  97.  
  98. static    unsigned char    yyToLower    [] = {
  99. '\0', '\1', '\2', '\3', '\4', '\5', '\6', '\7',
  100. '\10', '\11', '\12', '\13', '\14', '\15', '\16', '\17',
  101. '\20', '\21', '\22', '\23', '\24', '\25', '\26', '\27',
  102. '\30', '\31', '\32', '\33', '\34', '\35', '\36', '\37',
  103. ' ', '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/',
  104. '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?',
  105. '@', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
  106. 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '[', '\\', ']', '^', '_',
  107. '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
  108. 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', '\177',
  109. '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
  110. '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
  111. '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
  112. '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
  113. '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
  114. '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
  115. '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
  116. '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
  117. '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
  118. '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
  119. '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
  120. '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
  121. '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
  122. '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
  123. '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
  124. '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
  125. };
  126.  
  127. static    unsigned char    yyToUpper    [] = {
  128. '\0', '\1', '\2', '\3', '\4', '\5', '\6', '\7',
  129. '\10', '\11', '\12', '\13', '\14', '\15', '\16', '\17',
  130. '\20', '\21', '\22', '\23', '\24', '\25', '\26', '\27',
  131. '\30', '\31', '\32', '\33', '\34', '\35', '\36', '\37',
  132. ' ', '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/',
  133. '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?',
  134. '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
  135. 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_',
  136. '`', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
  137. 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '{', '|', '}', '~', '\177',
  138. '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
  139. '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
  140. '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
  141. '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
  142. '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
  143. '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
  144. '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
  145. '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
  146. '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
  147. '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
  148. '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
  149. '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
  150. '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
  151. '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
  152. '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
  153. '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
  154. };
  155.  
  156. static    void    yyInitialize    ();
  157. static    void    yyErrorMessage    ARGS((int yyErrorCode));
  158. static    char    input        ();
  159. $G global user declarations
  160.  
  161. $@ int $_GetToken ()
  162. {
  163.    register    yyStateRange    yyState;
  164.    register    yyStateRange *    yyStatePtr;
  165.    register    unsigned char * yyChBufferIndexReg;
  166.    register    yyCombType * *    yyBasePtrReg = yyBasePtr;
  167. $L local user declarations and actions
  168.  
  169. yyBegin:
  170.    yyState        = yyStartState;        /* initialize */
  171.    yyStatePtr        = & yyStateStack [1];
  172.    yyChBufferIndexReg     = yyChBufferIndex;
  173. $@    $_TokenPtr         = (char *) yyChBufferIndexReg;
  174. $J if (yyChBufferIndexReg [-1] == yyEolCh) yyState ++;
  175.  
  176.    /* ASSERT yyChBuffer [yyChBufferIndex] == first character */
  177.  
  178. yyContinue:        /* continue after sentinel or skipping blanks */
  179.    for (;;) {        /* execute as many state transitions as possible */
  180.                     /* determine next state and get next character */
  181.       register yyCombType * yyTablePtr = (yyBasePtrReg [yyState] + * yyChBufferIndexReg ++);
  182.       if (yyTablePtr->yyCheck == yyState) {
  183.      yyState = yyTablePtr->yyNext;
  184.      * yyStatePtr ++ = yyState;        /* push state */
  185.      goto yyContinue;
  186.       }
  187.       yyChBufferIndexReg --;            /* reconsider character */
  188.       if ((yyState = yyDefault [yyState]) == yyDNoState) break;
  189.    }
  190.  
  191.    for (;;) {                    /* search for last final state */
  192. $@       $_TokenLength = yyChBufferIndexReg - (unsigned char *) $_TokenPtr;
  193.       yyChBufferIndex = yyChBufferIndexReg;
  194. $A switch header and user actions    /* switch (* -- yyStatePtr) {    /* pop state */
  195. $N non final states
  196.      /* non final states */
  197.      yyChBufferIndexReg --;            /* return character */
  198.      break;
  199.  
  200. $P    case yyDefaultState:
  201. $@      $_Attribute.Position.Line   = yyLineCount;
  202. $@      $_Attribute.Position.Column = yyChBufferIndexReg - yyLineStart;
  203. $@       /* $_TokenLength   = 1; */
  204.      yyChBufferIndex = ++ yyChBufferIndexReg;
  205.      {
  206. $D default action
  207.      }
  208.      goto yyBegin;
  209.  
  210.       case yyDNoState:                /* automatic initialization */
  211.      yyInitialize ();
  212.      yySourceFile = StdIn;
  213.      goto yyBegin;
  214.  
  215. $O    case yyEobState:                /* end of buffer sentinel found */
  216.      yyChBufferIndex = -- yyChBufferIndexReg; /* undo last state transition */
  217. $@      if (-- $_TokenLength == 0) {        /* get previous state */
  218.         yyState = yyStartState;
  219. $J        if (yyChBufferIndexReg [-1] == yyEolCh) yyState ++;
  220.      } else {
  221.         yyState = * (yyStatePtr - 1);
  222.      }
  223.  
  224.      if (yyChBufferIndex != & yyChBufferStart [yyBytesRead]) {
  225.                         /* end of buffer sentinel in buffer */
  226.         if ((yyState = yyEobTrans [yyState]) == yyDNoState) continue;
  227.         yyChBufferIndexReg ++;
  228.         * yyStatePtr ++ = yyState;        /* push state */
  229.         goto yyContinue;
  230.      }
  231.                         /* end of buffer reached */
  232.      {  /* copy initial part of token in front of the input buffer */
  233. $@         register char * yySource = $_TokenPtr;
  234. $@         register char * yyTarget = $_TokenPtr = (char *) & yyChBufferPtr [yyMaxAlign - $_TokenLength % yyMaxAlign];
  235.         if (yySource != yyTarget) {
  236.            while (yySource < (char *) yyChBufferIndexReg) * yyTarget ++ = * yySource ++;
  237.            yyLineStart += (unsigned char *) yyTarget - yyChBufferStart - yyBytesRead;
  238.            yyChBufferStart = (unsigned char *) yyTarget;
  239.         } else {
  240.            yyChBufferStart = yyChBufferIndexReg;
  241.         }
  242.      }
  243.  
  244.      if (! yyEof) {                /* read buffer and restart */
  245. $@         int yyChBufferFree = (int) Exp2 (Log2 (yyChBufferSize - 4 - yyMaxAlign - $_TokenLength));
  246.         if (yyChBufferFree < yyChBufferSize / 8) {
  247.            register int yyDelta;
  248.            register unsigned char * yyOldChBufferPtr = yyChBufferPtr;
  249.            ExtendArray ((char * *) & yyChBufferPtr, & yyChBufferSize, sizeof (char));
  250.            if (yyChBufferPtr == NULL) yyErrorMessage (1);
  251.            yyDelta = yyChBufferPtr - yyOldChBufferPtr;
  252.            yyChBufferStart    += yyDelta;
  253.            yyLineStart    += yyDelta;
  254. $@            $_TokenPtr    += yyDelta;
  255. $@            yyChBufferFree = (int) Exp2 (Log2 (yyChBufferSize - 4 - yyMaxAlign - $_TokenLength));
  256.            if (yyStateStackSize < yyChBufferSize) {
  257.           yyStateRange * yyOldStateStack = yyStateStack;
  258.           ExtendArray ((char * *) & yyStateStack, & yyStateStackSize, sizeof (yyStateRange));
  259.           if (yyStateStack == NULL) yyErrorMessage (1);
  260.           yyStatePtr    += yyStateStack - yyOldStateStack;
  261.            }
  262.         }
  263.         yyChBufferIndex = yyChBufferIndexReg = yyChBufferStart;
  264. $@         yyBytesRead = $_GetLine (yySourceFile, (char *) yyChBufferIndex, yyChBufferFree);
  265.         if (yyBytesRead <= 0) { yyBytesRead = 0; yyEof = true; }
  266.         yyChBufferStart [yyBytesRead    ] = yyEobCh;
  267.         yyChBufferStart [yyBytesRead + 1] = '\0';
  268.         goto yyContinue;
  269.      }
  270.  
  271. $@      if ($_TokenLength == 0) {        /* end of file reached */
  272. $@         $_Attribute.Position.Line   = yyLineCount;
  273. $@         $_Attribute.Position.Column = yyChBufferIndexReg - yyLineStart;
  274. $@         $_CloseFile ();
  275.         if (yyFileStackPtr == yyFileStack) {
  276. $E eof action
  277.         }
  278. $@         if (yyFileStackPtr == yyFileStack) return $_EofToken;
  279.         goto yyBegin;
  280.      }
  281.      break;
  282.  
  283.       default:
  284.      yyErrorMessage (0);
  285.       }
  286.    }
  287. }
  288.  
  289. $@ void $_BeginFile
  290. # if defined __STDC__ | defined __cplusplus
  291.    (char * yyFileName)
  292. # else
  293.    (yyFileName) char * yyFileName;
  294. # endif
  295.    {
  296.       yyInitialize ();
  297. $@       yySourceFile = $_BeginSource (yyFileName);
  298.    }
  299.  
  300. static void yyInitialize ()
  301.    {
  302.       if (yyFileStackPtr >= yyFileStack + yyFileStackSize) yyErrorMessage (2);
  303.       yyFileStackPtr ++;            /* push file */
  304.       yyFileStackPtr->yySourceFile    = yySourceFile        ;
  305.       yyFileStackPtr->yyEof        = yyEof            ;
  306.       yyFileStackPtr->yyChBufferPtr    = yyChBufferPtr        ;
  307.       yyFileStackPtr->yyChBufferStart    = yyChBufferStart    ;
  308.       yyFileStackPtr->yyChBufferSize    = yyChBufferSize    ;
  309.       yyFileStackPtr->yyChBufferIndex    = yyChBufferIndex    ;
  310.       yyFileStackPtr->yyBytesRead    = yyBytesRead        ;
  311.       yyFileStackPtr->yyLineCount    = yyLineCount        ;
  312.       yyFileStackPtr->yyLineStart    = yyLineStart        ;
  313.                         /* initialize file state */
  314.       yyChBufferSize       = yyInitBufferSize;
  315.       MakeArray ((char * *) & yyChBufferPtr, & yyChBufferSize, sizeof (char));
  316.       if (yyChBufferPtr == NULL) yyErrorMessage (1);
  317.       yyChBufferStart       = & yyChBufferPtr [yyMaxAlign];
  318.       yyChBufferStart [-1] = yyEolCh;        /* begin of line indicator */
  319.       yyChBufferStart [ 0] = yyEobCh;        /* end of buffer sentinel */
  320.       yyChBufferStart [ 1] = '\0';
  321.       yyChBufferIndex       = yyChBufferStart;
  322.       yyEof           = false;
  323.       yyBytesRead       = 0;
  324.       yyLineCount       = 1;
  325.       yyLineStart       = & yyChBufferStart [-1];
  326.       if (yyStartState == 0) {
  327.      yyStartState       = STD;
  328.      yyStateStack [0]  = yyDefaultState;    /* stack underflow sentinel */
  329.       }
  330.    }
  331.  
  332. $@ void $_CloseFile ()
  333.    {
  334.       if (yyFileStackPtr == yyFileStack) yyErrorMessage (3);
  335. $@       $_CloseSource (yySourceFile);
  336.       ReleaseArray ((char * *) & yyChBufferPtr, & yyChBufferSize, sizeof (char));
  337.                         /* pop file */
  338.       yySourceFile    = yyFileStackPtr->yySourceFile        ;
  339.       yyEof        = yyFileStackPtr->yyEof            ;
  340.       yyChBufferPtr    = yyFileStackPtr->yyChBufferPtr        ;
  341.       yyChBufferStart    = yyFileStackPtr->yyChBufferStart    ;
  342.       yyChBufferSize    = yyFileStackPtr->yyChBufferSize    ;
  343.       yyChBufferIndex    = yyFileStackPtr->yyChBufferIndex    ;
  344.       yyBytesRead    = yyFileStackPtr->yyBytesRead        ;
  345.       yyLineCount    = yyFileStackPtr->yyLineCount        ;
  346.       yyLineStart    = yyFileStackPtr->yyLineStart        ;
  347.       yyFileStackPtr --;
  348.    }
  349.  
  350. $@ int $_GetWord
  351. # if defined __STDC__ | defined __cplusplus
  352.    (char * yyWord)
  353. # else
  354.    (yyWord) char * yyWord;
  355. # endif
  356.    {
  357. $@       register char * yySource            = $_TokenPtr;
  358.       register char * yyTarget            = yyWord;
  359.       register char * yyChBufferIndexReg    = (char *) yyChBufferIndex;
  360.  
  361.       do {                /* ASSERT word is not empty */
  362.      * yyTarget ++ = * yySource ++;
  363.       } while (yySource < yyChBufferIndexReg);
  364.       * yyTarget = '\0';
  365. $@       return yyChBufferIndexReg - $_TokenPtr;
  366.    }
  367.  
  368. $@ int $_GetLower
  369. # if defined __STDC__ | defined __cplusplus
  370.    (char * yyWord)
  371. # else
  372.    (yyWord) char * yyWord;
  373. # endif
  374.    {
  375. $@       register char * yySource            = $_TokenPtr;
  376.       register char * yyTarget            = yyWord;
  377.       register char * yyChBufferIndexReg    = (char *) yyChBufferIndex;
  378.  
  379.       do {                /* ASSERT word is not empty */
  380.      * yyTarget ++ = yyToLower [* yySource ++];
  381.       } while (yySource < yyChBufferIndexReg);
  382.       * yyTarget = '\0';
  383. $@       return yyChBufferIndexReg - $_TokenPtr;
  384.    }
  385.  
  386. $@ int $_GetUpper
  387. # if defined __STDC__ | defined __cplusplus
  388.    (char * yyWord)
  389. # else
  390.    (yyWord) char * yyWord;
  391. # endif
  392.    {
  393. $@       register char * yySource            = $_TokenPtr;
  394.       register char * yyTarget            = yyWord;
  395.       register char * yyChBufferIndexReg    = (char *) yyChBufferIndex;
  396.  
  397.       do {                /* ASSERT word is not empty */
  398.      * yyTarget ++ = yyToUpper [* yySource ++];
  399.       } while (yySource < yyChBufferIndexReg);
  400.       * yyTarget = '\0';
  401. $@       return yyChBufferIndexReg - $_TokenPtr;
  402.    }
  403.  
  404. static char input ()
  405.    {
  406.       if (yyChBufferIndex == & yyChBufferStart [yyBytesRead]) {
  407.      if (! yyEof) {
  408.         yyLineStart -= yyBytesRead;
  409.         yyChBufferIndex = yyChBufferStart = yyChBufferPtr;
  410. $@         yyBytesRead = $_GetLine (yySourceFile, (char *) yyChBufferIndex,
  411.            (int) Exp2 (Log2 (yyChBufferSize)));
  412.         if (yyBytesRead <= 0) { yyBytesRead = 0; yyEof = true; }
  413.         yyChBufferStart [yyBytesRead    ] = yyEobCh;
  414.         yyChBufferStart [yyBytesRead + 1] = '\0';
  415.      }
  416.       }
  417.       if (yyChBufferIndex == & yyChBufferStart [yyBytesRead]) return '\0';
  418.       else return * yyChBufferIndex ++;
  419.    }
  420.  
  421. $@ void $_BeginScanner ()
  422.    {
  423. $I user initialization code
  424.    }
  425.  
  426. $@ void $_CloseScanner ()
  427.    {
  428. $F user finalization code
  429.    }
  430.  
  431. static void yyErrorMessage
  432. # if defined __STDC__ | defined __cplusplus
  433.    (int yyErrorCode)
  434. # else
  435.    (yyErrorCode) int yyErrorCode;
  436. # endif
  437.    {
  438. $@       WritePosition (stderr, $_Attribute.Position);
  439.       switch (yyErrorCode) {
  440. $@       case 0: (void) fprintf (stderr, ": @: internal error\n"); break;
  441. $@       case 1: (void) fprintf (stderr, ": @: out of memory\n"); break;
  442. $@       case 2: (void) fprintf (stderr, ": @: too many nested include files\n"); break;
  443. $@       case 3: (void) fprintf (stderr, ": @: file stack underflow (too many calls of $_CloseFile)\n"); break;
  444.       }
  445. $@       @_Exit ();
  446.    }
  447.